package com.project.demo.controller;

import com.alipay.api.AlipayApiException;
import com.alipay.api.AlipayClient;
import com.alipay.api.DefaultAlipayClient;
import com.alipay.api.internal.util.AlipaySignature;
import com.alipay.api.request.AlipayTradeQueryRequest;
import com.alipay.api.response.AlipayTradeQueryResponse;
import com.project.demo.service.UserParticipationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * 支付回调控制器
 * 处理支付宝支付回调通知
 */
@Slf4j
@RestController
@RequestMapping("/payment")
public class PaymentController {

    @Autowired
    private UserParticipationService userParticipationService;

    // 支付宝配置（从application.yml读取）
    @Value("${payment.alipay.appId:}")
    private String alipayAppId;
    
    @Value("${payment.alipay.privateKey:}")
    private String alipayPrivateKey;
    
    @Value("${payment.alipay.publicKey:}")
    private String alipayPublicKey;
    
    @Value("${payment.alipay.serverUrl:https://openapi.alipay.com/gateway.do}")
    private String alipayServerUrl;
    
    @Value("${payment.alipay.signType:RSA2}")
    private String alipaySignType;
    
    @Value("${payment.alipay.charset:UTF-8}")
    private String alipayCharset;

    /**
     * 支付宝同步回调接口（支付成功后跳转回商户页面）
     * @param request HTTP请求
     * @return 重定向URL或HTML页面
     */
    @GetMapping("/alipay/return")
    @Transactional
    public String alipayReturn(HttpServletRequest request) {
        log.info("收到支付宝同步回调（return）");
        
        try {
            // 获取支付宝回调参数
            Map<String, String> params = getAllRequestParams(request);
            log.info("支付宝同步回调参数：{}", params);
            
            // 验证签名
            boolean signVerified = false;
            try {
                signVerified = AlipaySignature.rsaCheckV1(
                    params,
                    alipayPublicKey,
                    alipayCharset,
                    alipaySignType
                );
            } catch (AlipayApiException e) {
                log.error("支付宝同步回调签名验证失败", e);
                return "redirect:/user_participation/success?error=签名验证失败";
            }
            
            if (!signVerified) {
                log.error("支付宝同步回调签名验证失败，参数：{}", params);
                return "redirect:/user_participation/success?error=签名验证失败";
            }
            
            log.info("支付宝同步回调签名验证成功");
            
            // 获取订单信息
            String outTradeNo = params.get("out_trade_no"); // 商户订单号
            String tradeStatus = params.get("trade_status"); // 交易状态（可能为空）
            String tradeNo = params.get("trade_no"); // 支付宝交易号
            String totalAmount = params.get("total_amount"); // 交易金额
            String appId = params.get("app_id"); // 支付宝应用ID
            
            log.info("同步回调 - 订单号：{}，交易状态：{}，支付宝交易号：{}，交易金额：{}", 
                outTradeNo, tradeStatus, tradeNo, totalAmount);
            
            // 验证app_id
            if (appId != null && !alipayAppId.equals(appId)) {
                log.error("同步回调 app_id不匹配：期望{}，实际{}", alipayAppId, appId);
                return "redirect:/user_participation/success?error=app_id不匹配";
            }
            
            // 在同步回调中也尝试更新支付状态（即使异步回调可能已经更新）
            // 这样即使异步回调失败，同步回调也能更新状态
            Integer userParticipationId = findUserParticipationByOrderNo(outTradeNo);
            
            if (userParticipationId != null) {
                // 直接更新支付状态，不检查当前状态（因为可能存在并发或缓存问题）
                // 即使已经是"已支付"，也再次更新以确保数据一致性
                Map<String, String> query = new HashMap<>();
                query.put("user_participation_id", userParticipationId.toString());
                Map<String, String> config = new HashMap<>();
                
                // 先查询当前状态用于日志记录（但不影响更新逻辑）
                javax.persistence.Query selectQuery = userParticipationService.select(query, config);
                List resultList = selectQuery.getResultList();
                String currentPayStateBefore = "未知";
                if (resultList != null && resultList.size() > 0) {
                    try {
                        Object obj = resultList.get(0);
                        // 尝试多种方法名（驼峰和蛇形命名）
                        java.lang.reflect.Method getPayState = null;
                        try {
                            getPayState = obj.getClass().getMethod("getPay_state");
                        } catch (NoSuchMethodException e) {
                            try {
                                getPayState = obj.getClass().getMethod("getPayState");
                            } catch (NoSuchMethodException e2) {
                                log.warn("无法找到pay_state的getter方法", e2);
                            }
                        }
                        if (getPayState != null) {
                            Object payStateObj = getPayState.invoke(obj);
                            currentPayStateBefore = payStateObj != null ? payStateObj.toString() : "null";
                        }
                    } catch (Exception e) {
                        log.warn("无法检查当前支付状态", e);
                    }
                }
                
                log.info("同步回调 - 当前支付状态: {}, 将更新为'已支付' - user_participation_id: {}", 
                    currentPayStateBefore, userParticipationId);
                
                // 无论当前状态如何，都执行更新操作（确保数据一致性）
                {
                    // 更新支付状态
                    Map<String, Object> updateData = new HashMap<>();
                    updateData.put("pay_state", "已支付");
                    updateData.put("pay_type", "支付宝");
                    updateData.put("update_time", new java.sql.Timestamp(System.currentTimeMillis()));
                    
                    log.info("准备更新支付状态 - user_participation_id: {}, 订单号: {}, 更新数据: {}", 
                        userParticipationId, outTradeNo, updateData);
                    log.info("查询条件Map: {}", query);
                    log.info("配置Map: {}", config);
                    
                    try {
                        // 确保事务提交
                        userParticipationService.update(query, config, updateData);
                        
                        // 等待一小段时间，确保数据库更新完成
                        Thread.sleep(100);
                        
                        // 验证更新是否成功
                        javax.persistence.Query verifyQuery = userParticipationService.select(query, config);
                        List verifyResult = verifyQuery.getResultList();
                        if (verifyResult != null && verifyResult.size() > 0) {
                            try {
                                Object obj = verifyResult.get(0);
                                java.lang.reflect.Method getPayState = obj.getClass().getMethod("getPay_state");
                                String updatedPayState = (String) getPayState.invoke(obj);
                                if ("已支付".equals(updatedPayState)) {
                                    log.info("同步回调更新支付状态成功 - user_participation_id: {}, 订单号: {}, 当前状态: {}", 
                                        userParticipationId, outTradeNo, updatedPayState);
                                } else {
                                    log.error("同步回调更新支付状态失败 - 状态未改变！user_participation_id: {}, 订单号: {}, 当前状态: {}", 
                                        userParticipationId, outTradeNo, updatedPayState);
                                }
                            } catch (Exception e) {
                                log.warn("无法验证更新后的支付状态", e);
                                log.info("同步回调已执行更新操作 - user_participation_id: {}, 订单号: {}", 
                                    userParticipationId, outTradeNo);
                            }
                        } else {
                            log.error("同步回调更新后验证失败 - 找不到记录！user_participation_id: {}, 订单号: {}", 
                                userParticipationId, outTradeNo);
                        }
                    } catch (Exception e) {
                        log.error("同步回调更新支付状态时发生异常 - user_participation_id: {}, 订单号: {}", 
                            userParticipationId, outTradeNo, e);
                        throw e; // 重新抛出异常，让上层处理
                    }
                }
                
                // 重定向到前端成功页面
                // 使用相对路径，让浏览器自动处理（前端路由是 /user_participation/success）
                // 注意：Spring的redirect如果返回相对路径，会重定向到当前域名，这不是我们想要的
                // 我们需要重定向到前端域名（可能是不同的端口），所以需要使用HTML方式重定向
                // 但Spring MVC的redirect不支持跨域重定向，所以返回一个HTML页面进行跳转
                String frontendSuccessUrl = "/user_participation/success?order_number=" + outTradeNo 
                    + "&user_participation_id=" + userParticipationId;
                log.info("支付成功，将重定向到前端页面: {}", frontendSuccessUrl);
                
                // 返回HTML页面，使用多种方式确保跳转到前端（前端在8081或8082端口）
                // 这里假设前端在8081端口，如果是其他端口需要修改
                String escapedOrderNumber = outTradeNo.replace("'", "\\'").replace("\"", "&quot;");
                String escapedUserId = userParticipationId.toString().replace("'", "\\'").replace("\"", "&quot;");
                String frontendPort = "8081"; // 前端端口，可以根据需要修改
                
                String html = "<!DOCTYPE html>" +
                    "<html>" +
                    "<head>" +
                    "<meta charset='UTF-8'>" +
                    "<title>支付成功</title>" +
                    // 使用meta refresh作为备用跳转方案
                    "<meta http-equiv='refresh' content='0;url=http://localhost:" + frontendPort + "/user_participation/success?order_number=" + escapedOrderNumber + "&user_participation_id=" + escapedUserId + "'>" +
                    "</head>" +
                    "<body>" +
                    "<p>支付成功，正在跳转...</p>" +
                    "<script type='text/javascript'>" +
                    "// 立即跳转（优先级高于meta refresh）" +
                    "(function() {" +
                    "  var orderNumber = '" + escapedOrderNumber + "';" +
                    "  var userId = '" + escapedUserId + "';" +
                    "  var currentHost = window.location.hostname;" +
                    "  var frontendPort = '" + frontendPort + "';" +
                    "  var frontendUrl = 'http://' + currentHost + ':' + frontendPort + '/user_participation/success?order_number=' + encodeURIComponent(orderNumber) + '&user_participation_id=' + encodeURIComponent(userId);" +
                    "  console.log('准备跳转到:', frontendUrl);" +
                    "  // 优先使用location.replace，避免在历史记录中留下后端回调页面" +
                    "  if (window.location.replace) {" +
                    "    window.location.replace(frontendUrl);" +
                    "  } else {" +
                    "    window.location.href = frontendUrl;" +
                    "  }" +
                    "})();" +
                    "</script>" +
                    "</body>" +
                    "</html>";
                
                log.info("返回重定向HTML页面，前端地址: http://localhost:{}/user_participation/success?order_number={}&user_participation_id={}", 
                    frontendPort, outTradeNo, userParticipationId);
                return html;
            } else {
                log.error("同步回调未找到对应的用户参会记录，订单号：{}", outTradeNo);
                log.error("订单号解析流程：");
                log.error("  1. 订单号：{}", outTradeNo);
                log.error("  2. findUserParticipationByOrderNo返回null");
                log.error("  3. 可能原因：订单号格式不正确或记录不存在");
                
                // 即使找不到记录，也重定向到前端页面，但带上错误信息
                String html = "<!DOCTYPE html><html><head><meta charset='UTF-8'><title>支付处理</title></head><body>" +
                    "<script>" +
                    "var orderNumber = '" + outTradeNo + "';" +
                    "var currentHost = window.location.hostname;" +
                    "var frontendPort = '8081';" +
                    "var frontendUrl = 'http://' + currentHost + ':' + frontendPort + '/user_participation/success?order_number=' + orderNumber + '&error=未找到对应的参会记录';" +
                    "window.location.href = frontendUrl;" +
                    "</script>" +
                    "<p>正在处理支付结果...</p>" +
                    "</body></html>";
                return html;
            }
            
        } catch (Exception e) {
            log.error("处理支付宝同步回调失败", e);
            String html = "<!DOCTYPE html><html><head><meta charset='UTF-8'><title>支付处理错误</title></head><body>" +
                "<script>" +
                "var currentHost = window.location.hostname;" +
                "var frontendPort = '8081';" +
                "var frontendUrl = 'http://' + currentHost + ':' + frontendPort + '/user_participation/success?error=处理失败';" +
                "window.location.href = frontendUrl;" +
                "</script>" +
                "<p>处理支付结果时发生错误，正在跳转...</p>" +
                "</body></html>";
            return html;
        }
    }
    
    /**
     * 支付宝异步回调接口（支付成功后支付宝服务器主动通知）
     * @param request HTTP请求
     * @return 处理结果
     */
    @PostMapping("/alipay/notify")
    public String alipayNotify(HttpServletRequest request) {
        log.info("收到支付宝支付回调通知");
        
        try {
            // 获取支付宝回调参数
            Map<String, String> params = getAllRequestParams(request);
            log.info("支付宝回调参数：{}", params);
            
            // 验证签名
            boolean signVerified = false;
            try {
                signVerified = AlipaySignature.rsaCheckV1(
                    params,
                    alipayPublicKey,
                    alipayCharset,
                    alipaySignType
                );
            } catch (AlipayApiException e) {
                log.error("支付宝签名验证失败", e);
                return "failure";
            }
            
            if (!signVerified) {
                log.error("支付宝签名验证失败，参数：{}", params);
                return "failure";
            }
            
            log.info("支付宝签名验证成功");
            
            // 获取订单信息
            String outTradeNo = params.get("out_trade_no"); // 商户订单号
            String tradeStatus = params.get("trade_status"); // 交易状态
            String tradeNo = params.get("trade_no"); // 支付宝交易号
            String totalAmount = params.get("total_amount"); // 交易金额
            String appId = params.get("app_id"); // 支付宝应用ID
            
            log.info("订单号：{}，交易状态：{}，支付宝交易号：{}，交易金额：{}", 
                outTradeNo, tradeStatus, tradeNo, totalAmount);
            
            // 验证app_id
            if (!alipayAppId.equals(appId)) {
                log.error("app_id不匹配：期望{}，实际{}", alipayAppId, appId);
                return "failure";
            }
            
            // 处理支付成功
            if ("TRADE_SUCCESS".equals(tradeStatus) || "TRADE_FINISHED".equals(tradeStatus)) {
                // 根据订单号查找用户参会记录
                // 订单号格式可能是：订单编号或 user_participation_id
                Integer userParticipationId = findUserParticipationByOrderNo(outTradeNo);
                
                if (userParticipationId != null) {
                // 直接更新支付状态，不检查当前状态（因为可能存在并发或缓存问题）
                // 即使已经是"已支付"，也再次更新以确保数据一致性
                Map<String, String> query = new HashMap<>();
                query.put("user_participation_id", userParticipationId.toString());
                Map<String, String> config = new HashMap<>();
                
                // 先查询当前状态用于日志记录（但不影响更新逻辑）
                javax.persistence.Query selectQuery = userParticipationService.select(query, config);
                List resultList = selectQuery.getResultList();
                String currentPayStateBefore = "未知";
                if (resultList != null && resultList.size() > 0) {
                    try {
                        Object obj = resultList.get(0);
                        // 尝试多种方法名（驼峰和蛇形命名）
                        java.lang.reflect.Method getPayState = null;
                        try {
                            getPayState = obj.getClass().getMethod("getPay_state");
                        } catch (NoSuchMethodException e) {
                            try {
                                getPayState = obj.getClass().getMethod("getPayState");
                            } catch (NoSuchMethodException e2) {
                                log.warn("无法找到pay_state的getter方法", e2);
                            }
                        }
                        if (getPayState != null) {
                            Object payStateObj = getPayState.invoke(obj);
                            currentPayStateBefore = payStateObj != null ? payStateObj.toString() : "null";
                        }
                    } catch (Exception e) {
                        log.warn("无法检查当前支付状态", e);
                    }
                }
                
                log.info("异步回调 - 当前支付状态: {}, 将更新为'已支付' - user_participation_id: {}", 
                    currentPayStateBefore, userParticipationId);
                
                // 无论当前状态如何，都执行更新操作（确保数据一致性）
                // 更新支付状态
                Map<String, Object> updateData = new HashMap<>();
                updateData.put("pay_state", "已支付");
                updateData.put("pay_type", "支付宝");
                updateData.put("update_time", new java.sql.Timestamp(System.currentTimeMillis()));
                
                log.info("准备更新支付状态 - user_participation_id: {}, 订单号: {}, 交易号: {}, 更新数据: {}", 
                    userParticipationId, outTradeNo, tradeNo, updateData);
                log.info("查询条件Map: {}", query);
                log.info("配置Map: {}", config);
                
                try {
                    // 确保事务提交
                    userParticipationService.update(query, config, updateData);
                    
                    // 等待一小段时间，确保数据库更新完成
                    Thread.sleep(100);
                    
                    // 验证更新是否成功
                    javax.persistence.Query verifyQuery = userParticipationService.select(query, config);
                    List verifyResult = verifyQuery.getResultList();
                    if (verifyResult != null && verifyResult.size() > 0) {
                        try {
                            Object obj = verifyResult.get(0);
                            java.lang.reflect.Method getPayState = obj.getClass().getMethod("getPay_state");
                            String updatedPayState = (String) getPayState.invoke(obj);
                            if ("已支付".equals(updatedPayState)) {
                                log.info("异步回调更新支付状态成功 - user_participation_id: {}, 订单号: {}, 交易号: {}, 当前状态: {}", 
                                    userParticipationId, outTradeNo, tradeNo, updatedPayState);
                            } else {
                                log.error("异步回调更新支付状态失败 - 状态未改变！user_participation_id: {}, 订单号: {}, 当前状态: {}", 
                                    userParticipationId, outTradeNo, updatedPayState);
                            }
                        } catch (Exception e) {
                            log.warn("无法验证更新后的支付状态", e);
                            log.info("异步回调已执行更新操作 - user_participation_id: {}, 订单号: {}", 
                                userParticipationId, outTradeNo);
                        }
                    } else {
                        log.error("异步回调更新后验证失败 - 找不到记录！user_participation_id: {}, 订单号: {}", 
                            userParticipationId, outTradeNo);
                    }
                } catch (Exception e) {
                    log.error("异步回调更新支付状态时发生异常 - user_participation_id: {}, 订单号: {}", 
                        userParticipationId, outTradeNo, e);
                    // 异步回调不抛出异常，避免支付宝重复通知
                }
            } else {
                    log.error("异步回调未找到对应的用户参会记录，订单号：{}", outTradeNo);
                    log.error("订单号解析流程：");
                    log.error("  1. 订单号：{}", outTradeNo);
                    log.error("  2. findUserParticipationByOrderNo返回null");
                    log.error("  3. 可能原因：订单号格式不正确或记录不存在");
                }
                
                // 无论是否更新成功，都返回success，避免支付宝重复通知
                return "success";
            } else {
                log.info("交易状态不是成功状态：{}", tradeStatus);
                return "success"; // 仍然返回success，避免支付宝重复通知
            }
            
        } catch (Exception e) {
            log.error("处理支付宝回调失败", e);
            return "failure";
        }
    }
    
    /**
     * 根据订单号查找用户参会记录
     * 订单号格式：ORDER_{user_participation_id}_{timestamp}{random}
     * 例如：ORDER_123_202411011234567890
     */
    private Integer findUserParticipationByOrderNo(String outTradeNo) {
        try {
            log.info("尝试解析订单号：{}", outTradeNo);
            
            // 方法1：如果订单号以 ORDER_ 开头，提取 user_participation_id
            if (outTradeNo.startsWith("ORDER_")) {
                String[] parts = outTradeNo.split("_");
                log.info("订单号拆分结果，parts.length: {}, parts: {}", parts.length, java.util.Arrays.toString(parts));
                
                if (parts.length >= 2) {
                    try {
                        Integer id = Integer.parseInt(parts[1]);
                        log.info("从订单号提取 user_participation_id: {} (订单号: {})", id, outTradeNo);
                        
                        // 验证记录是否存在
                        Map<String, String> query = new HashMap<>();
                        query.put("user_participation_id", id.toString());
                        Map<String, String> config = new HashMap<>();
                        javax.persistence.Query result = userParticipationService.select(query, config);
                        List resultList = result != null ? result.getResultList() : null;
                        
                        if (resultList != null && resultList.size() > 0) {
                            log.info("找到用户参会记录，user_participation_id: {} (订单号: {})", id, outTradeNo);
                            return id;
                        } else {
                            log.error("未找到对应的用户参会记录，user_participation_id: {} (订单号: {})", id, outTradeNo);
                            log.error("可能的原因：1) 记录还未插入数据库 2) user_participation_id不匹配");
                        }
                    } catch (NumberFormatException e) {
                        log.error("订单号格式解析失败，无法提取 user_participation_id: {}，异常: {}", outTradeNo, e.getMessage());
                    }
                } else {
                    log.error("订单号格式不正确，parts.length < 2，订单号: {}", outTradeNo);
                }
            }
            
            // 方法2：如果订单号格式正确但ID不存在，尝试查找最近的未支付记录
            // 这可以处理订单号生成时使用了错误ID的情况
            if (outTradeNo != null && outTradeNo.startsWith("ORDER_")) {
                try {
                    String[] parts = outTradeNo.split("_");
                    if (parts.length >= 3) {
                        // 提取时间戳部分（可能是订单号格式：ORDER_28_202510311650524401）
                        String timestampPart = parts[2];
                        log.info("尝试通过时间戳匹配订单号: {}, 时间戳部分: {}", outTradeNo, timestampPart);
                        
                        // 查找最近创建的记录（按创建时间倒序，限制10条）
                        Map<String, String> config = new HashMap<>();
                        config.put("order", "create_time desc");
                        config.put("limit", "10");
                        javax.persistence.Query recentQuery = userParticipationService.select(new HashMap<>(), config);
                        List recentList = recentQuery != null ? recentQuery.getResultList() : null;
                        
                        if (recentList != null && recentList.size() > 0) {
                            log.info("找到 {} 条最近记录，尝试匹配订单号", recentList.size());
                            // 这里可以进一步匹配，但为了简化，我们直接返回第一条最近的记录
                            // 更精确的匹配可以通过比较时间戳来实现
                            for (Object obj : recentList) {
                                try {
                                    java.lang.reflect.Method getId = obj.getClass().getMethod("getUser_participation_id");
                                    Object idObj = getId.invoke(obj);
                                    if (idObj != null) {
                                        Integer recentId = Integer.parseInt(idObj.toString());
                                        log.info("找到最近记录，user_participation_id: {}, 尝试使用此ID", recentId);
                                        // 由于无法精确匹配，这里返回最近的记录ID（可能不准确，但至少可以更新）
                                        // 更好的方案是在订单号中包含更多信息，或者使用数据库字段存储订单号
                                        return recentId;
                                    }
                                } catch (Exception e) {
                                    log.warn("无法从记录中获取ID", e);
                                }
                            }
                        }
                    }
                } catch (Exception e) {
                    log.warn("通过时间戳匹配订单号失败", e);
                }
            }
            
            // 方法3：尝试直接作为 user_participation_id（纯数字）
            try {
                Integer id = Integer.parseInt(outTradeNo);
                log.info("尝试将订单号直接作为 user_participation_id: {}", id);
                Map<String, String> query = new HashMap<>();
                query.put("user_participation_id", id.toString());
                Map<String, String> config = new HashMap<>();
                javax.persistence.Query result = userParticipationService.select(query, config);
                if (result != null && result.getResultList().size() > 0) {
                    log.info("找到用户参会记录，user_participation_id: {}", id);
                    return id;
                }
            } catch (NumberFormatException e) {
                // 不是数字格式
            }
            
            // 方法4：通过支付宝交易号查询（需要调用支付宝API）
            // 这里暂时不实现，因为需要额外的API调用
            
            log.warn("无法通过订单号找到用户参会记录，订单号：{}", outTradeNo);
            log.warn("提示：请确保订单号格式为 ORDER_{user_participation_id}_{timestamp}{random}");
            log.warn("如果订单号中的ID不存在，可能是前端传递了错误的 user_participation_id");
            
        } catch (Exception e) {
            log.error("查找用户参会记录失败", e);
        }
        
        return null;
    }
    
    /**
     * 获取所有请求参数
     */
    private Map<String, String> getAllRequestParams(HttpServletRequest request) {
        Map<String, String> params = new HashMap<>();
        Map<String, String[]> requestParams = request.getParameterMap();
        
        for (Iterator<String> iter = requestParams.keySet().iterator(); iter.hasNext();) {
            String name = iter.next();
            String[] values = requestParams.get(name);
            String valueStr = "";
            for (int i = 0; i < values.length; i++) {
                valueStr = (i == values.length - 1) ? valueStr + values[i] : valueStr + values[i] + ",";
            }
            params.put(name, valueStr);
        }
        
        return params;
    }
    
    /**
     * 查询订单支付状态（用于主动查询，不依赖回调）
     */
    @RequestMapping("/alipay/query")
    public Map<String, Object> queryAlipayOrder(String outTradeNo) {
        Map<String, Object> result = new HashMap<>();
        
        try {
            log.info("查询支付宝订单状态 - 订单号: {}", outTradeNo);
            
            if (outTradeNo == null || outTradeNo.isEmpty()) {
                log.error("订单号为空，无法查询");
                result.put("success", false);
                result.put("message", "订单号不能为空");
                return result;
            }
            
            // 查询接口需要私钥来签名请求
            if (alipayPrivateKey == null || alipayPrivateKey.isEmpty()) {
                log.error("支付宝私钥未配置，无法查询订单状态");
                result.put("success", false);
                result.put("message", "支付宝私钥未配置");
                return result;
            }
            
            AlipayClient alipayClient = new DefaultAlipayClient(
                alipayServerUrl,
                alipayAppId,
                alipayPrivateKey, // 查询接口需要私钥来签名请求
                "JSON",
                alipayCharset,
                alipayPublicKey,
                alipaySignType
            );
            
            AlipayTradeQueryRequest request = new AlipayTradeQueryRequest();
            request.setBizContent("{\"out_trade_no\":\"" + outTradeNo + "\"}");
            
            log.info("调用支付宝查询接口，请求参数: {}", request.getBizContent());
            AlipayTradeQueryResponse response = alipayClient.execute(request);
            log.info("支付宝查询接口响应: success={}, tradeStatus={}, subMsg={}", 
                response.isSuccess(), response.getTradeStatus(), response.getSubMsg());
            
            if (response.isSuccess()) {
                result.put("success", true);
                result.put("trade_status", response.getTradeStatus());
                result.put("trade_no", response.getTradeNo());
                result.put("total_amount", response.getTotalAmount());
                log.info("支付宝订单查询成功 - 订单号: {}, 状态: {}, 交易号: {}", 
                    outTradeNo, response.getTradeStatus(), response.getTradeNo());
            } else {
                result.put("success", false);
                result.put("message", response.getSubMsg());
                log.warn("支付宝订单查询失败 - 订单号: {}, 错误: {}", outTradeNo, response.getSubMsg());
            }
            
        } catch (Exception e) {
            log.error("查询支付宝订单状态失败 - 订单号: {}", outTradeNo, e);
            result.put("success", false);
            result.put("message", e.getMessage());
        }
        
        return result;
    }
    
    /**
     * 主动查询并更新支付状态（用于前端支付成功页面调用）
     * 即使回调没有到达，也能通过这个接口主动更新数据库
     */
    @RequestMapping("/alipay/check_and_update")
    public Map<String, Object> checkAndUpdatePaymentStatus(String orderNumber, String userParticipationId) {
        // 注意：这个方法返回的 Map 会被 BaseController.success() 包装成 {result: {...}}
        // 但 PaymentController 不继承 BaseController，所以直接返回 result
        Map<String, Object> result = new HashMap<>();
        
        try {
            log.info("========== 主动查询支付状态 ==========");
            log.info("订单号: {}", orderNumber);
            log.info("user_participation_id: {}", userParticipationId);
            
            if (orderNumber == null || orderNumber.isEmpty()) {
                log.error("订单号为空，无法查询支付状态");
                result.put("success", false);
                result.put("message", "订单号不能为空");
                Map<String, Object> response = new HashMap<>();
                response.put("result", result);
                return response;
            }
            
            if (userParticipationId == null || userParticipationId.isEmpty()) {
                log.warn("user_participation_id为空，将尝试从订单号解析");
            }
            
            // 1. 先查询支付宝订单状态
            log.info("开始查询支付宝订单状态，订单号: {}", orderNumber);
            Map<String, Object> queryResult = queryAlipayOrder(orderNumber);
            log.info("支付宝订单状态查询结果: {}", queryResult);
            
            if (!Boolean.TRUE.equals(queryResult.get("success"))) {
                String errorMsg = queryResult.get("message") != null ? 
                    queryResult.get("message").toString() : "查询订单状态失败";
                log.error("查询支付宝订单状态失败: {}", errorMsg);
                result.put("success", false);
                result.put("message", errorMsg);
                // 使用 BaseController 的格式包装返回
                Map<String, Object> response = new HashMap<>();
                response.put("result", result);
                return response;
            }
            
            String tradeStatus = (String) queryResult.get("trade_status");
            log.info("支付宝订单状态: {}", tradeStatus);
            
            // 2. 如果支付成功，更新数据库
            if ("TRADE_SUCCESS".equals(tradeStatus) || "TRADE_FINISHED".equals(tradeStatus)) {
                // 根据 user_participation_id 更新支付状态
                Integer participationId = null;
                if (userParticipationId != null && !userParticipationId.isEmpty()) {
                    try {
                        participationId = Integer.parseInt(userParticipationId);
                    } catch (NumberFormatException e) {
                        log.warn("user_participation_id 格式错误: {}", userParticipationId);
                    }
                }
                
                // 如果 user_participation_id 无效，尝试从订单号解析
                if (participationId == null) {
                    participationId = findUserParticipationByOrderNo(orderNumber);
                }
                
                if (participationId != null) {
                    // 更新支付状态
                    Map<String, Object> updateData = new HashMap<>();
                    updateData.put("pay_state", "已支付");
                    updateData.put("pay_type", "支付宝");
                    updateData.put("update_time", new java.sql.Timestamp(System.currentTimeMillis()));
                    
                    Map<String, String> query = new HashMap<>();
                    query.put("user_participation_id", participationId.toString());
                    
                    Map<String, String> config = new HashMap<>();
                    
                    log.info("准备主动更新支付状态 - user_participation_id: {}, 订单号: {}, 更新数据: {}", 
                        participationId, orderNumber, updateData);
                    
                    // 执行更新
                    try {
                        userParticipationService.update(query, config, updateData);
                        
                        // 验证更新是否成功（查询更新后的记录）
                        javax.persistence.Query verifyQuery = userParticipationService.select(query, config);
                        List verifyResult = verifyQuery != null ? verifyQuery.getResultList() : null;
                        
                        if (verifyResult != null && verifyResult.size() > 0) {
                            // 进一步验证支付状态是否已更新
                            Object obj = verifyResult.get(0);
                            // 使用反射获取 pay_state 字段值（如果可能）
                            try {
                                java.lang.reflect.Method getPayState = obj.getClass().getMethod("getPay_state");
                                String payState = (String) getPayState.invoke(obj);
                                if ("已支付".equals(payState)) {
                                    log.info("主动更新支付状态成功 - user_participation_id: {}, 订单号: {}, 当前状态: {}", 
                                        participationId, orderNumber, payState);
                                    result.put("success", true);
                                    result.put("message", "支付状态更新成功");
                                    result.put("pay_state", "已支付");
                                } else {
                                    log.error("主动更新支付状态失败 - 状态未改变！user_participation_id: {}, 订单号: {}, 当前状态: {}", 
                                        participationId, orderNumber, payState);
                                    result.put("success", false);
                                    result.put("message", "支付状态未正确更新，当前状态: " + payState);
                                }
                            } catch (Exception e) {
                                // 如果无法验证，假设更新成功
                                log.warn("无法验证更新后的支付状态", e);
                                log.info("主动更新支付状态 - user_participation_id: {}, 订单号: {} (无法验证状态)", 
                                    participationId, orderNumber);
                                result.put("success", true);
                                result.put("message", "支付状态更新成功");
                                result.put("pay_state", "已支付");
                            }
                        } else {
                            log.error("主动更新后验证失败，记录不存在 - user_participation_id: {}, 订单号: {}", 
                                participationId, orderNumber);
                            result.put("success", false);
                            result.put("message", "更新后验证失败，记录不存在");
                        }
                    } catch (Exception e) {
                        log.error("主动更新支付状态时发生异常 - user_participation_id: {}, 订单号: {}", 
                            participationId, orderNumber, e);
                        result.put("success", false);
                        result.put("message", "更新失败: " + e.getMessage());
                    }
                } else {
                    log.warn("未找到对应的用户参会记录，订单号: {}, user_participation_id: {}", 
                        orderNumber, userParticipationId);
                    result.put("success", false);
                    result.put("message", "未找到对应的用户参会记录");
                }
            } else {
                log.info("订单尚未支付成功，状态: {}", tradeStatus);
                result.put("success", false);
                result.put("message", "订单尚未支付成功，状态: " + tradeStatus);
                result.put("trade_status", tradeStatus);
            }
            
        } catch (Exception e) {
            log.error("查询并更新支付状态失败", e);
            result.put("success", false);
            result.put("message", "处理失败: " + e.getMessage());
        }
        
        // 包装成标准格式返回
        Map<String, Object> response = new HashMap<>();
        response.put("result", result);
        return response;
    }
}

